RT_SECURE_NO_WARNINGS 1

#include<iostream>
using namespace std;

//template<typename T>
//void Swap(T& left, T& right) {
//	T temp = left;
//	left = right;
//	right = temp;
//}

//template<class T> T Add(const T& left, const T& right) {
//	return left + right;
//}
//int main()
//{
//	int a1 = 10, a2 = 20;
//	double d1 = 10.5, d2 = 20.5;
//
//	//Add(a1, d1);
//	//  该语句不能通过编译，因为在编译期间，当编译器看到该实例化时，需要推演其实参类型
//	//  通过实参a1将T推演为int，通过实参d1将T推演为double类型，但模板参数列表中只有
//      //一个T，
//	//  编译器无法确定此处到底该将T确定为int 或者 double类型而报错
//	 // 注意：在模板中，编译器一般不会进行类型转换操作，因为一旦转化出问题，编译器就需要
//      //背黑锅
//	//  Add(a1, d1);
//	// 
//	// 此时有两种处理方式：1. 用户自己来强制转化 2. 使用显式实例化
//	//1
//	Add(a1, (int)d1);
//	//2.
//	Add<int>(a1, d1);
//	return 0;
//}


//int main()
//{
//	int a = 10;
//	int b = 20;
//	double c = 1.5;
//	double d = 3.5;
//	Swap(a, b);
//	Swap(c, d);
//	cout << a << " "<< b << endl;
//	cout << c << " " << d << endl;
//	return 0;
//}


 // 专门处理int的加法函数
int Add(int left, int right)
{
	return left + right;
}

//// 通用加法函数
//template<class T1, class T2>
//T1 Add(T1 left, T2 right)
//{
//	return left + right;
//}
//
//void Test()
//{
//	Add(1, 2);   // 与非函数模板类型完全匹配，不需要函数模板实例化
//	Add(1, 2.0); // 模板函数可以生成更加匹配的版本，编译器根据实参生成更加匹配的
//	//Add函数
//}

#include<string>
using std::string;

template<class T1,class T2>
class Student
{
public:
	Student(const string& name, const string& sex,const T1& age,const T2& height)
	{
		_age = age;
		_height = height;
		_name = name;
		_sex = sex;
		
	}

	~Student();

	void Print()
	{
		cout << _name << endl;
		cout << _sex << endl;
		cout << _age << endl;
		cout << _height << endl;
	}
private:
	string _name;
	string _sex;
	T1 _age;
	T2 _height;
};

template<class T1, class T2>
Student<T1, T2>::~Student()
{
	//逻辑实现
}

int main()
{
	Student<int, double> st1("zhangsan", "nan", 18.5, 180.5);
	Student<double, int>  st2("lisi", "nv", 25.5, 160.5);

	st1.Print();
	st2.Print();
	return 0;
}


